这篇文章是为「码上开学」写的，首发于码上开学官网 。

引子

找到那把三叉戟，你便能号令整个海洋。 ——《海王》

为什么需要新语言

Java是当今世界最流行的工业级语言，有着非常成熟的生态和广泛的开发群体。当初Android选择Java作为开发语言，也是为了吸引Java程序员这个世界上最大的开发群体。最早的一批Android程序员可能已经用Java写了近十年Android程序了，各种实践方法也比较成熟了。那么今天我们为什么还需要一门新语言呢？这就要从Java的发行历史说起了。

Java历史

其实从Java 5开始，Java就是一门很完备的工业级语言了，生态也非常成熟，各种框架层出不穷。但是后续的Java 6和Java 7只是在Java 5基础上添加了一些功能和语法糖，根本算不上大版本更新，我觉得版本号定为5.1，5.2可能更合适。如果你稍微了解过同期的C#，看看Lambda和LINQ，你大概也会对Java怒其不争吧。

直到2014年Java 8正式发布，才算是Java语言的一次大更新，加入了呼声很高的Lambda和stream。可是等等，Android是哪一年发布的？2008年！所以Android是以Java 6来进行开发。虽然从Android Studio 3.0开始可以使用部分Java 8特性进行开发了，但是非常好用的stream只能在Android 7.0以上使用（即minSdkVersion = 24）。受困于Android版本碎片化，我们只能放弃。那么用Java 6写代码到底有什么问题呢？

从一道算法题说起

请听题：有一个英文小写单词列表List\<String>，要求将其按首字母分组（key为 ‘a’ - ‘z’），并且每个分组内的单词列表都是按升序排序，得到一个Map\<Character, List\<String>>。请尝试用10行以内Java 6.0代码完成。

1
2
3
4
5
6
7
8
9
10
11
12

List<String> keywords = ...;
Map<Character, List<String>> result = new HashMap<>();
for (String k: keywords) {
    char firstChar = k.charAt(0);
    if (!result.contains(firstChar)) {
        result.put(firstChar, new ArrayList<String>());
    }
    result.get(firstChar).add(k);
}
for (List<String> list: result.values()) {
    Collections.sort(list);
}

实际上已经超过10行了。我们再看看业界标杆C#是怎么写的

1
2
3
4
5
6

List<string> keywords = …;
var result = keywords
        .GroupBy(k => k[0])
        .ToDictionary(
            g => g.Key,
            g => g.OrderBy(k => k).ToList());

为了代码可读性，我添加了一些换行。如果你愿意的话，写成一行也行。可以明显看出，对比当今先进语言，Java 6已经无法让人愉快的写代码。用Java 6写代码时，我们脑子里想的不是要做什么，而是怎么做。

Java平台

我们平时说Java，其实包含了两个不同的概念：一是Java语言本身，二是Java虚拟机，即JVM。虽然上面吐槽了Java语言本身的历史包袱，但是JVM还是非常优秀的，它有非常多的优点：

• 跨平台
• 自动垃圾回收
• 运行速度快（你没看错。虽然Java程序速度没有C/C++快，但是在所有编程语言中Java属于速度快的那一拨。大数据框架Hadoop便是用Java开发，能顺利处理海量数据。）

我们知道Java代码编译后会生成字节码，然后字节码在JVM中运行注意Android中的虚拟机并不是JVM，而是Dalvik/ART，但也是编译成字节码。那么有没有可能新创造一门语言，编译的时候也生成字节码，然后在JVM中运行呢？这样既可以摆脱Java的历史包袱，又能享受到JVM和成熟Java框架的各种好处！答案当然是肯定的！实际上Java平台已经衍生出Scala、Clojure、Groovy等比较流行的语言了。而今天我们要讲的Kotlin则是Java平台中的新贵，出自大名鼎鼎的JetBrains公司。打开他们的官网你就会发现，很多著名的IDE（比如IntelliJ、RubyMine、WebStorm）都是出自这家公司。IntelliJ是当今最主流的Java IDE，JetBrains公司在开发IntelliJ的过程中积累的经验令Kotlin的诞生显得水到渠成。而Google在2017年的I/O大会上宣布Kotlin成为Android开发的官方编程语言后，更是令Kotlin一夜之间成为最受瞩目的编程语言之一。那么我们来看看Kotlin会给我们带来哪些好处吧。

Kotlin带来的好处

Data Class

假设你在做一个金融交易系统，需要定义一个Class来表示每一笔支付，包含金额和币种。这里有一个简单的例子：

1
2
3
4

public class Purchase {
    public String currency;
    public int price; //为了便于演示，这里将价格设为整数类型
}

看起来不错。但是作为一个经验丰富的程序员，你一眼就发现了潜藏的问题。一个金融系统，一定是要保证每笔交易的正确性的，你肯定不希望object中的currency和price的值在某个模块里面被粗心的人修改了。所以你需要一个Immutable Class，即不可更改的类。于是你做了如下修改：

1
2
3
4
5
6
7
8
9
10
11
12

public class Purchase {
    private String currency;
    private int price;

    public Purchase(String currency, int price) {
        this.currency = currency;
        this.price = price;
    }

    public String getCurrency() { return this.currency; }
    public int getPrice() { return this.price; }
}

你将currency和price定义为private field，通过构造方法来赋值，并且只暴露get方法。这样就不用担心数据被其他人误修改了。完美！可是等等，这就够了吗？熟读《Java编程思想》的你立刻想起，一个完备的Class还需要重写equals()、hashCode()和toString()方法！于是你又添加了一些代码：

1
2
3
4
5
6
7

public class Purchase {
    ...

    public boolean equals(Object o) {}
    public hashCode() {}
    public String toString() {}
}

我就问你烦不烦:) 仅仅是表示金额和币种，怎么要写那么多代码？如果有十几个字段，那还不得上百行代码呀？！请看Kotlin中优雅的实现：

1

data class Purchase(val currency: String, val price: int)

没了。

一行代码搞定:)

关键字val会自动为currency和price创建不可更改的field，而data则会帮我们自动生成equals()、hashCode()和toString()方法！这还不是全部，看下面的代码：

1
2

val iPhone8 = Purchase(“CNY”, 5888)
val iPhoneX = iPhone8.copy(price = 8888)

看到copy方法了吗？是不是巨好用？这也是data class为我们自动生成的，方便吧:)

Extension Functions

Kotlin中的Extension类似于Objective-C中的Category，可以帮助我们扩展已有的Class，而无需继承这个Class，无论我们能不能访问源码。这对于系统Class以及一些第三方library中的Class特别有帮助。

随着项目规模的扩大，你的代码里肯定少不了一系列Utils类（比如FileUtils.java，DateUtils.java）来封装一些繁琐但常用的功能。比如在Android开发中，如果我们要动态的调整一个View的宽高，必须要先将dp转为px，所以我们会有这样一个方法：

1
2
3
4
5

public class ScreenUtil {
    public static int dip2px(float dipValue) {
        return (int) (dipValue * density + 0.5f);
    }
}

然后这样使用：

1

layoutParams.width = ScreenUtil.dip2px(16F)

这样看起来没什么不对，只是不太符合人的阅读习惯。看看用Extension能帮我们做些什么：

1
2
3

fun Int.toPx(): Int {
    return ScreenUtil.dip2px(this.toFloat())
}

我们给整数类型添加了一个Extension Function，叫做toPx，用来实现dp到px的转换。然后优雅的调用：

1

layoutParams.width = 16.toPx()

可读性是不是好多了🙂。你可能会想，Extension一个一个自己写也挺麻烦的，有没有大神把常用的Extension Functions封装成一个library啊？有的，Google爸爸已经帮我们考虑到了😘。请参看Android KTX项目。这个项目是Android Jetpack的一部分，而Jetpack也是我们接下来要分享的内容。

Null Safety

这是一个值得吹上三天三夜的革新。在Quora上有这样一个问题：为什么空指针异常被称为10亿美金的错误？相信每一个Java程序员都对这个问题深有体会。看看我们为了避免程序崩溃，不得不写多么丑陋的代码：

1
2
3

if (a != null && a.b != null && a.b.c != null) {
    println(a.b.c.toString());
}

这样写有两个问题，一是代码很丑陋，二是本少爷很容易忘记做空指针检查啊😤！！！Java 8引入了Optional来解决这个问题，比自己检查空指针要稍微优雅一点，但仍然有许多不必要的代码包装。

Kotlin的类型系统从一开始就致力于避免空指针异常。我们在Kotlin中定义变量时可以指定它为可空类型（Nullable Type）和不可空类型（Non-Null Type）。

1
2
3
4
5
6
7
8

var a: String = "abc" // 不可空
a = null // 编译报错
print(a.length) // 没问题

var b: String? = "abc" // 可空
b = null // 没问题
print(b.length) // 编译报错
print(b?.length) // 没问题

上例的a是Non-Null，而b是Nullable。他们的唯一区别是定义的时候b的String后面加了个问号?，代表它是Nullable的。只有Nullable类型可以赋值为null。调用Nullable对象的方法时，需要加一个问号，像b?.length。如果b为null，那么print(b?.length)这行代码不会被执行。这样设计有什么好处呢？回到我们上一个例子，如果我们将a，a.b，a.b.c都定义为Nullable，那么就可以这样写：

1

println(a?.b?.c?.toString())

如果它们中间任意一个为null，那么 a?.b?.c?.toString() 这个 chain 就会返回 null 。是不是很强大很方便？理论上讲，只要我们的类型定义合理，那么90%的空指针异常都是能避免。为什么我不敢说100%？因为有时候我们看设计文档确定某个值绝对不可能为null，于是给它定义为Non-Null，结果程序运行时偏偏就传过来一个null……😂

Courtines

Android开发中多线程处理一直是一个难点，稍微不小心就容易出问题。你可能已经学习过RxJava，并在项目中成功使用RxJava来处理线程问题。这非常好。但是如果你的业务逻辑并没有复杂到必须用RxJava来解决，你应该看看Kotlin中的Courtines。Courtines通常翻译成_协程，在Lua等程序语言中已经有着广泛的应用。它的概念稍微有些复杂，我们可以暂时认为它是一种无需锁_并且没有线程切换开销的轻量级线程。

我们看一个例子，假设我需要从网络取回来一些数据，然后保存到数据库，那么传统的异步回调写法是这样的：

1
2
3
4
5

networkRequest { result ->
   databaseSave(result) { rows ->
     // Result saved
   }
}

而用Courtines的写法是这样的：

1
2
3

val result = networkRequest()
databaseSave(result)
// Result saved

你可能已经发现了，这段代码根本不关心线程如何切换，只关心我到底要实现什么功能。实际上Courtines背后远比这要复杂，想要熟练使用需要经历一些学习曲线，但好在曲线并不算陡峭。我们后面会有专门文章来讲解如合使用Courtines。如果你已经激动的等不及了（和第一次知道Courtines时的我一样），可以先跟着Google Codelabs中的教程来练练手。

与Java的交互

虽然前面我们讲到，Java平台上的语言都会编译成字节码，但这并不代表所有语言都能与Java无缝交互。比如Scala和Java的交互就非常复杂。幸运的是，JetBrains从一开始就将与Java的交互性作为Kotlin的设计目标之一。无论是从Java调用Kotlin，还是从Kotlin调用Java，都非常自然，没有什么障碍。这意味着我们可以任意使用Java丰富的第三方库，也可以在现有的Java工程基础上用Kotlin添加新的功能。万一你遇到某些特殊情况，有一段逻辑用Kotlin搞不定（我写这篇文章时就遇到一个），可以把这段逻辑抽出来用Java写。有Java兜底，我们就能放心的为项目引入Kotlin了。

无障碍升级

我们前面讲到，要想在Android开发中使用Java 8中的stream，需要设定minSdkVersion = 24。如果将来要使用Java 9的新特性，恐怕又得等Android版本更新了。Kotlin则不同，你可以把它当作一个集成到项目中的第三方library，可以随时升级到最新版本！这意味着Kotlin将来推出的更多新特性都能应用到所有Android项目中！

迁移到Kotlin会遇到什么问题

前面讲了Kotlin的这么多好处，但要知道世上没有十全十美的语言。就Kotlin而言，目前社区反映比较多的问题是可见性修饰符（Visibility Modifiers）。我们知道Java中有四种访问权限：public，protected，private和package-private。其中package-private是指在同一个包名下可见，在library开发中非常方便。而在Kotlin中没有了package-private，取而代之的是internal，即在同一个模块（Module）内可见。这样我们在设计library时必须对可见性控制有更周全的考虑。为Android开发library，不可避免的要重写系统方法。如果你用重写了一个Java中的package-private方法，那么不好意思，这个方法会变成public🤣，原本并不想暴露出来的方法暴露了……

如果你主要做应用开发，那么目前已经没有什么坑了。Google已经逐渐用Kotlin重写Android文档中的所有例子，Github上用Kotlin开发的项目也在飞快增长。社区方面，在StackOverflow做的2018年度调查中，Kotlin更是一举登上最受欢迎语言榜第二名！就像前面讲的，万一有问题还有Java兜底。所以你唯一需要考虑的可能就是团队学习成本。好在Kotlin是一门非常简易、现代的语言，相信做这个决定并不困难。

回到最开始

我想肯定有好事的人要问，最开始那个算法题用Kotlin怎么写呢？

1
2
3
4

val keywords = arrayOf("apple", "app", "alpha", ...)
val result = keywords
        .groupBy { it[0] }
        .mapValues { it.value.sorted() }

你还在等什么？

为什么要用Chrome Custom Tabs？

当App需要打开一个网站时，开发者面临两种选择：默认浏览器或WebView。这两种选择都有不足。从App跳转到浏览器是一个非常重的切换，并且浏览器无法自定义；而WebView无法与浏览器共享cookies等数据，并且需要开发者处理非常多的场景。

Chrome Custom Tabs提供了一种新的选择，既能在App和网页之间流畅切换，又能有多种自定义选项。其实它本质上是调用了Chrome中的一个Activity来打开网页，这样想就能理解这些优点了。能自定义的项目有：

• Toolbar颜色

• 进场和出场动画

• Toolbar上的action button，menu item和bottom toolbar（通过RemoveView实现）

Chrome Custom Tabs还提供预启动Chrome和预加载网页内容的功能，与传统方式相比加载速度有显著提升。

什么时候用Chrome Custom Tabs，什么时候用WebView？

如果Web页面是你自己的内容（比如淘宝商品页之于手机淘宝），那么WebView是最好的选择，因为你可能需要针对网页内容及用户操作做非常多的自定义。如果是跳到一个外部网站，比如在App中点了一个广告链接跳转到广告商的网站，那么建议使用Chrome Custom Tabs。

前置条件

用户的手机上需要安装Chrome 45或以上版本，并且设为默认浏览器。考虑到Chrome在国内手机上的占有率，这确实是个问题……但如果你的APP不只是面对国内市场，那么以Google在海外市场的影响力，这完全不是问题。

肯定有人要问，如果手机上没有装Chrome，调用Chrome Custom Tabs会发生什么行为呢？我们查看CustomTabsIntent.Builder的源码可以发现，Builder的内部构造了一个action为Intent.ACTION_VIEW的Intent，所以答案是调用默认浏览器来打开URL。

这时我们可以发现Chrome Custom Tabs的原理：如果Chrome是默认浏览器，那么这个Intent自然就会唤起Chrome，然后Chrome会根据Intent的各个Extra来配置前面所讲的自定义项。这里有一个隐藏的好处：如果你的工作恰好是开发浏览器，那么也可以根据这些Extra信息来定制界面！

开发向导

快速上手

首先在你的build.gradle文件中加入dependency

1
2
3
4

dependencies {
    ...
    compile 'com.android.support:customtabs:24.1.1'
}

然后写几行代码

1
2
3
4

String url = "https://www.google.com";
CustomTabsIntent.Builder builder = new CustomTabsIntent.Builder();
CustomTabsIntent customTabsIntent = builder.build();
customTabsIntent.launchUrl(this, Uri.parse(url));

就好了！不费吹灰之力~

注意launchUrl这个方法的第一个参数是个Activity。肯定有人会跳起来说，我要在ViewHolder里面处理点击跳转，根本拿不到Activity，只有Context肿么办？！！（其实这个人就是我）

那么我们看看launchUrl的源码：

1
2
3
4

public void launchUrl(Activity context, Uri url) {
    intent.setData(url);
    ActivityCompat.startActivity(context, intent, startAnimationBundle);
}

原来是为了传入startAnimationBundle这个参数来实现自定义转场动画。那么我们自己处理一下就好了：

1
2
3
4
5
6
7
8
9
10
11

if (context instanceof Activity) {
    customTabsIntent.launchUrl((Activity) context, uri);
} else {
    Intent intent = customTabsIntent.intent;
    intent.setData(uri);
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
        context.startActivity(intent, customTabsIntent.startAnimationBundle);
    } else {
        context.startActivity(intent);
    }
}

修改Toolbar颜色

你一定希望Chrome Custom Tabs的Toolbar颜色与你自己APP的Toolbar颜色保持相同，看起来就像是在APP内打开网页一样。一行代码搞定：

1

builder.setToolbarColor(colorInt);

添加action button

你可能想要在Toolbar上加上action button，那么需要创建一个PendingIntent。下面的代码增加了一个发送邮件的action button：

1
2
3
4
5
6
7

Intent actionIntent = new Intent(Intent.ACTION_SEND);
actionIntent.setType("*/*");
actionIntent.putExtra(Intent.EXTRA_EMAIL, "example@example.com");
actionIntent.putExtra(Intent.EXTRA_SUBJECT, "example");
PendingIntent pi = PendingIntent.getActivity(this, 0, actionIntent, 0);
Bitmap icon = BitmapFactory.decodeResource(getResources(), R.drawable.ic_share);//注意在正式项目中不要在UI线程读取图片
builder.setActionButton(icon, "send email", pi, true);

添加menu item

Chrome Custom Tabs的menu默认包含了三个显示为图标的item(Forward, Page Info, Refresh)和两个文字item(Find in page, Open in Browser)。我们可以再添加最多5个文字item。同样需要创建PendingIntent：

1
2
3
4

Intent menuIntent = new Intent();
menuIntent.setClass(getApplicationContext(), SomeActivity.class);
PendingIntent pi = PendingIntent.getActivity(getApplicationContext(), 0, menuIntent, 0);
builder.addMenuItem("Menu entry 1", pi);

设置转场动画

如果你的APP设置了转场动画，那么为了统一的用户体验，可以在Chrome Custom Tabs中设置同样的动画

1
2

builder.setStartAnimations(this, R.anim.slide_in_right, R.anim.slide_out_left);
builder.setExitAnimations(this, R.anim.slide_in_left, R.anim.slide_out_right);

预启动(Warm up) Chrome和预加载

默认情况下，调用了CustomTabsIntent#launchUrl方法之后，才会在后台启动（原文是spin up）Chrome，然后加载网页。这个过程会花费宝贵的时间，并影响到用户体验。要是能「秒开」网页那就爽了。Chrome Custom Tabs可以绑定Chrome的一个Service，绑定成功之后可以预启动Chrome，还可以让Chrome预加载一些网页（当然这是要消耗一些流量的）。大致的过程是这样的：

• 通过CustomTabsClient#bindCustomTabsService方法绑定Service。绑定成功后会得到一个CustomTabsClient的instance。如果绑定失败，说明Chrome版本过低或者没有安装。
• 通过CustomTabsClient#warmup方法在后台启动Chrome。
• 通过CustomTabsClient#newSession方法创建一个新的session。这一步还可以传入一个CustomTabsCallback参数用来得到session的状态，比如页面是否加载完成。
• 通过CustomTabsSession#mayLaunchUrl来告诉Chrome要预加载哪些网页。
• 当用户点击事件发生时，将前面那个session传入CustomTabsIntent.Builder，然后用文章最开头的方法打开网页。

下面是完成这个过程的简单代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

public class MainActivity extends Activity implements ServiceConnectionCallback {
    private CustomTabsSession mSession;
    private CustomTabsClient mClient;
    private CustomTabsServiceConnection mConnection;
  
    ...
    
    private void bindCustomTabsService() {
        mConnection = new ServiceConnection(this);
        CustomTabsClient.bindCustomTabsService(this, "com.android.chrome", mConnection);
    }
  
    private void warmup() {
        if (mClient != null) mClient.warmup(0);
    }
  
    private void preLaunch(String url) {
        if (mClent != null && mSession == null) {
            mSession = mClient.newSession(new CustomTabsCallback({
                @Override
                public void onNavigationEvent(int navigationEvent, Bundle extras) {
                    // 这里可以取到Session的状态
                }
            }));
        }
        mSession.mayLaunchUrl(Uri.parse(url), null, null);//这里的第三个参数可以传入一些低优先级的Url，但不能保证会被预加载
    }
  
    private void launch(String url) {
        CustomTabsIntent.Builder builder = new CustomTabsIntent.Builder(mSession);
        CustomTabsIntent customTabsIntent = builder.build();
        customTabsIntent.launchUrl(this, Uri.parse(url));
    }
  
    @Override
    public void onDestroy() {
        if (mConnection != null) {
            unbindService(mConnection);
            mClient = null;
            mSession = null;
        }
        super.onDestroy();
    }
  
    /** ServiceConnectionCallback的回调方法 */
    @Override
    public void onServiceConnected(CustomTabsClient client) {
        mClient = client;
    }
  
    @Override
    public void onServiceDisconnected() {
        mClient = null;
    }
}

简单的预启动

Android Support Library 24.0.0开始加入了CustomTabsClient#connectAndInitialize方法来简化预启动代码。如果你无法预料到用户会打开哪个URL，或者出于省电的考虑不想预加载URL，那么可以在Activity的onStart中加入一行代码来预启动。

1

CustomTabsClient.connectAndInitialize(this, "com.android.chrome");

最佳实践

绑定Custom Tabs的service并预启动

预启动Chrome可以帮助你节省高达700ms的宝贵时间！这几乎是可以划分卡与不卡的差别。启动过程是在后台以低优先级进行，所以不会对你的APP性能有负面影响。

预加载网页内容

预加载网页后可以达到秒开的效果！所以如果你至少有50%的把握用户会打开某个URL，你应当调用mayLaunchUrl()方法。这个方法会提前下载并渲染网页内容，但不可避免的会有一点流量和电量的消耗。如果用户正在使用收费的数据流量，或者手机电量不足，那么这个方法不会生效。所以我们完全不用自己考虑性能优化。

备选方案

如果用户的手机上没有安装Chrome，那么打开默认浏览器可能并不是最好的用户体验。所以如果在bindService那一步失败了，无论是打开默认浏览器还是WebView，选择一个你认为最好的备选方案。

referrer

很多网站都会统计自己的流量是从哪儿来的，所以最好告诉他们是你的帅气APP给他们带来了流量：

1
2

intent.putExtra(Intent.EXTRA_REFERRER, 
        Uri.parse(Intent.URI_ANDROID_APP_SCHEME + "//" + context.getPackageName()));

加入自定义动画

自定义的转场动画会让你的网页跳转更流畅。确保进场动画和出场动画是反向的，比如网页从右边进来，就从右边出去，这样能帮助用户理解跳转关系。

1
2

builder.setStartAnimations(this, R.anim.slide_in_right, R.anim.slide_out_left);
builder.setExitAnimations(this, R.anim.slide_in_left, R.anim.slide_out_right);

为Action Button选个合适的图标

一个合适的图标能让用户快速的理解到APP的功能。但记住图标的最大尺寸是宽48dp高24dp。

其他支持的浏览器

前面有讲到其他浏览器也有机会支持Custom Tabs的功能（虽然我还没发现有哪款已经支持了）。如果你检测到不止一个浏览器支持Custom Tabs，那么第一次调用时最好询问用户打算用哪个浏览器。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

/**
 * Returns a list of packages that support Custom Tabs.
 */ 
public static ArrayList getCustomTabsPackages(Context context) {
    PackageManager pm = context.getPackageManager();
    // Get default VIEW intent handler.
    Intent activityIntent = new Intent(Intent.ACTION_VIEW, Uri.parse("http://www.example.com"));

    // Get all apps that can handle VIEW intents.
    List resolvedActivityList = pm.queryIntentActivities(activityIntent, 0);
    ArrayList packagesSupportingCustomTabs = new ArrayList<>();
    for (ResolveInfo info : resolvedActivityList) {
        Intent serviceIntent = new Intent();
        serviceIntent.setAction(ACTION_CUSTOM_TABS_CONNECTION);
        serviceIntent.setPackage(info.activityInfo.packageName);
        // Check if this package also resolves the Custom Tabs service.
        if (pm.resolveService(serviceIntent, 0) != null) {
            packagesSupportingCustomTabs.add(info);
        }
    }
    return packagesSupportingCustomTabs;
}

给用户选择权

如果你的APP之前一直是用默认浏览器打开URL，后来才加入的Custom Tabs，那么老用户可能希望保留原来的习惯。可以考虑在设置里面增加一个选项，让用户自行选择。

尽量让Native APP处理URL

有些URL可以由Native APP处理。如果用户安装了Twitter的APP并且点击了Twitter的URL，他可能更期望用Twitter APP打开。所以在打开URL之前，检查看看手机里有没有其他APP可以处理这个URL。

自定义Toolbar颜色

如果你希望用户觉得网页内容是你的APP的一部分，那么就将Toolbar颜色设为你的primaryColor。如果希望清除的表明网页内容与APP无关，那么选个不同的颜色吧。

增加一个分享按钮

用户可能想要把URL分享给好友，但Custom Tabs默认并没有分享按钮，所以最好自己加个吧。

自定义关闭按钮

Custom Tabs左上角的关闭按钮默认是一个叉叉。如果你希望用户感觉到网页内容是APP的一部分，那么最好把叉叉换成返回按钮。

1

builder.setCloseButtonIcon(BitmapFactory.decodeResource(getResources(), R.drawable.ic_arrow_back));

分清内部链接和外部链接

举个例子，如果用户在Twitter APP里点击了一个http://twitter.com开头的URL，那么应该在APP内部处理。Custom Tabs只应用来处理外部链接。

处理连击

如果你想在用户点击URL到打开Custom Tabs之间的这段时间做一点准备工作，确保不要超过100ms，否则用户可能会觉得APP没有反应而再次点击。

然而你懂的在Android上是无法完全避免卡顿的，所以当用户反复点击同一个URL时，你应该只将URL打开一次。

结尾

如果你的APP是使用默认浏览器打开URL，那么身为一个合格的开发者，即使你的APP只在国内上架，也应该加入Custom Tabs支持。毕竟国内还是有一些会科学上网的用户使用Chrome的。更重要的是，我们这些开发者如果看到有国内APP使用了Custom Tabs，会欣慰的点个赞！

dp, sp, px间的转换

传统的java写法通常是写个类似Util.dpToPx(int value)这样的方法。看看Kotlin是怎么通过Extension来优雅的解决的：

1
2
3
4
5
6

fun Int.dpToPx(): Int {
    if (toInt() in intArrayOf(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT)) {
        return this
    }
    return (this * Global.density).toInt() //这里的Gloabl.density是在应用启动时获取的
}

然后就可以这样写了：params.topMargin = 16.dpTpPx()

是不是感动到哭😭

设置View的宽高

如果用java来写通常也是会有个Util方法ViewHelper.setSize(View view, int width, int height)，我每次在ViewHolder中调用一堆这样的方法都觉得很蛋疼……我们的救世主来了：

1
2
3
4
5
6

fun View.setSize(width: Int, height: Int) {
    val params = layoutParams
    params.width = width
    params.height = height
    layoutParams = params
}

注意这里的layoutParams是Kotlin将setLayoutParams()和getLayoutParams()自动转为了Property，写过C#的应该不会陌生。然后我们就可以愉快的写代码了~yourView.setSize(100, 100)

View的动画

每次写Animation都是一个头两个大……这回我们不看java了，直接上Kotlin代码：

1
2
3
4
5
6
7
8
9
10
11
12
13

fun View.animateTopMargin(valueFromInDP: Int, valueToInDP: Int, duration: Long = 300) {
    val animation = object: Animation() {
        override fun applyTransformation(interpolatedTime: Float, t: Transformation?) {
            val params = layoutParams as ViewGroup.MarginLayoutParams
            val from = valueFromInDP.dpToPx()
            val to = valueToInDP.dpToPx()
            params.topMargin = from + ((to - from) * interpolatedTime).toInt()
            layoutParams = params
        }
    }
    animation.duration = duration
    startAnimation(animation)
}

哇，duration还贴心的设了个默认值呢！然后就可以这样写了~yourView.animateTopMargin(16, 32)或者你想把duration设长一点yourView.animateTopMargin(16, 32, 500)

让Fresco更易用

Fresco是Facebook出品的网络图片加载库，实现了许多在android上非常有用的功能。比如Multi-URI功能可以优先显示低分辨率的图片，等高分辨率的图片下载完成后再进行替换。这个功能在移动设备上太太太有用了，就是写起来有点蛋疼：

1
2
3
4
5
6
7

Uri lowResUri, highResUri;
DraweeController controller = Fresco.newDraweeControllerBuilder()
    .setLowResImageRequest(ImageRequest.fromUri(lowResUri))
    .setImageRequest(ImageRequest.fromUri(highResUri))
    .setOldController(mSimpleDraweeView.getController())
    .build();
mSimpleDraweeView.setController(controller);

于是我又祭出了神器Extension

1
2
3
4
5
6
7
8

fun SimpleDraweeView.setMultiUri(lowResUri: Uri, highResUri: Uri) {
    val newController = Fresco.newDraweeControllerBuilder()
            .setLowResImageRequest(ImageRequest.fromUri(lowResUri))
            .setImageRequest(ImageRequest.fromUri(highResUri))
            .setOldController(controller)
            .build();
    controller = newController
}

然后怎么使用我就不写了，大家都知道了:smiley:

焕然一新的SharedPreference

你看到这里可能觉得不过是扩展方法嘛，Obj-C也可以做到啊，没什么嘛。哈哈哈哈图样图森破！有请Delegated Properties！下面这段代码来源于Omar Miatello在今年米兰的GDG DevFest的演讲

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

class AppPreferences(private val context: Context) {
    val preferences: SharedPreferences = PreferenceManager.getDefaultSharedPreferences(context)
    var userName by PreferenceDelegates.string(defaultValue = context.getString(R.string.user_name))
    var password by PreferenceDelegates.string()
}

object PreferenceDelegates {
    public fun string(defaultValue: String? = null): ReadWriteProperty<AppPreferences, String?> {
        return PrefString(defaultValue)
    }
}

private class PrefString(private val defaultValue: String?) : ReadWriteProperty<AppPreferences, String?> {
    override fun getValue(thisRef: AppPreferences, property: KProperty<*>): String? {
        return thisRef.preferences.getString(property.name, defaultValue)
    }

    override fun setValue(thisRef: AppPreferences, property: KProperty<*>, value: String?) {
        thisRef.preferences.edit().putString(property.name, value).apply()
    }
}

Hmm，乍一看有点摸不着头脑呢……简单的讲，AppPreferences这个class里面有两个delegate property，分别是userName和password。他们的get和set方法分别对应了SharedPreference中的getString和setString方法。纳尼？这么神奇？？？接着往下看

1
2
3
4
5
6
7
8

class App: Application() {
    val pref by lazy { AppPreferences(this) }
    
    override fun onCreate() {
        super.onCreate()
        // 其他代码
    }
}

在Application中定义了pref，注意它被by lazy修饰了，这样它就只在第一次调用的时候初始化，是不是很方便？

1
2
3
4

open class BaseActivity: AppCompatActivity() {
    val app by lazy { application as App }
    val pref by lazy { app.pref }
}

这里我们在所有Activity的父类中引入了pref，即AppPreferences的实例。然后……就可以爽了~~

1
2
3
4
5
6
7
8
9
10

class MyActivity: BaseActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        pref.userName = "Who"
        pref.password = "You"
        Log.d("userName", pref.userName)
        Log.d("password", pref.password)
    }
}

看到没有，用起来简直和field一毛一样！再也不用写pref.edit().putString("userName", "Who").apply()了！！！老板再也不用担心我把SharedPreference的key写错了😂

Lambdas

这个话题可就大了，一本书都讲不完，举个例子好了。RxJava现在很火，光头哥写了一篇很好的文章介绍了RxJava在android中的应用。抄一段代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

getUser(userId)
    .doOnNext(new Action1<User>() {
        @Override
        public void call(User user) {
            processUser(user);
        })
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(new Observer<User>() {
        @Override
        public void onNext(User user) {
            userView.setUser(user);
        }

        @Override
        public void onCompleted() {
        }

        @Override
        public void onError(Throwable error) {
            // Error handling
            ...
        }
    });

嗯，链式调用，很清晰，但用Kotlin还可以更简洁：

1
2
3
4
5
6
7
8

getUser(userId)
    .doOnNext{ user -> processUser(user) }
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe({
        user -> userView.setUser(user)
    },{
        error -> // Error handling
    })

Done!收拾东西下班回家~

风险

我知道你在担心什么。Kotlin目前还是beta版，用于正式项目要评估风险。事实上在第一个beta版中就出现了在android 4.3设备上无法安装的bug，好在官方很快就修复了。怎么讲呢，这是需要项目组全体成员一起评估的问题。我之所以敢在实际项目中使用，一是因为项目比较简单，万一遇到不可解决的问题可以改用java写，反正Kotlin和java可以无缝混用；二是因为程序员就我一个人，胆子粗啊哈哈哈哈~

感想

整个项目做下来让我感到很愉悦，代码的优雅足以说服我冒一点点风险。开发过程中我常常在想，要是有一个包含各种扩展方法的library就好了，我就不用自己造小轮子了。但转念一下，我真的需要一个完整的library吗？那必然会像Guava一样成为一个巨无霸，但实际用到的功能可能只有10%。在Kotlin的官方Slack里Jake Wharton（没错就是那个大神）提了一个有趣的思路：在一个git里放了很多不同类别的扩展方法文件（比如ViewExt.kt，IntExt.kt），需要哪个文件就把它pull下来，而不是compile整个jar包。如果能用gradle实现就太方便了😆

补充资料

Antonio Leiva写了一本书Kotlin for Android Developers，价格实惠干货满满，值得购买。配套的源码在https://github.com/antoniolg/Kotlin-for-Android-Developers

1、直接在StoryBoard里面将控件添加到Prototype Cell中。

2、新增一个Class（比如MyTableViewCell）继承UITableViewCell。

3、将Prototype Cell的Class设为MyTableViewCell。

4、按住control将控件拖到MyTableViewCell中，添加outlet。

1
2

@property (nonatomic, strong) IBOutlet UILable *label;
@property (nonatomic, strong) IBOutlet UIImageView *image;

5、直接调用

1

MyTableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:CELL_IDENTITY forIndexPath:indexPath];

搞定~

在Kotlin中，if是一个表达式，它有返回类型。因此Kotlin中不再需要三元表达式。

1

var max = if (a > b) a else b

if分支也可以是代码块（blocks），代码块的末尾是返回值。

1
2
3
4
5
6
7

var max = if (a > b) {
  print("Choose a")
  a // a会被赋值给max
} else {
  print("Choose b")
  b // b会被赋值给max
}

When Expression

when替代了switch语句，简单的例子像这样：

1
2
3
4
5
6
7

when (x) {
  1 -> print("x == 1")
  2 -> print("x == 2")
  else -> {
    print("x is neither 1 or 2")
  }
}

如果多个分支使用同样的处理逻辑，那么可以用逗号将它们结合起来：

1
2
3
4

when (x) {
  1, 2 -> print("x == 1 or x == 2")
  else -> print("otherwise")
}

分支中除了使用常量（上例中的1、2），也可以使用函数（arbitrary expressions）：

1
2
3
4

when (x) {
  parseInt(s) -> print("s encodes x")
  esle -> print("s does not encode x")
}

也可以用in或!in判断一个值是否在一个范围（range）或集合（collection）中：

1
2
3
4
5
6

when (x) {
  in 1...10 -> print("x is in the range")
  in validNumbers -> print("x is valid")
  !in 10...20 -> print("x is outside the range")
  else -> print("none of the above")
}

还可以用is或!is来检查一个值是否是某个类型：

1
2
3
4

val hasPrefix = when(x) {
  is String -> x.startsWith("prefix") // 注意这里s已经被自动转为String类型了
  else -> false
}

when还可以用来取代if-else if。如果没有传参数，那么分支条件就是简单的boolean表达式，当条件为true时分支就会被执行：

1
2
3
4
5

when {
  x.isOdd() -> print("x is odd")
  x.isEven() -> print("x is even")
  else -> print("x is funny")
}

For Loops

感觉没什么特别的，跟Java一样：

1
2
3
4
5

for (item in collection)
  print(item)
  
for (i in array.indices)
  print(array[i])

While Loops

也没什么特别的：

1
2
3
4
5
6
7

while (x > 0) {
  x--
}

do {
  val y = retrieveData()
} while (y != null) // 注意虽然y是在大括号内部定义的，但这里仍然可以访问到

下面我们来看一下Kotlin中的基本类型。

Numbers

Kotlin提供的数字类型和Java很像：

值得注意的是，定义Long形要用大写L：123L

而16进制和二进制则和Java一样：0x0F 0b0101

8进制则不支持。

浮点型和Java一样，类似123.45默认为Double类型，想要Float类型则应写成123.45f

在Java平台中，Number是基本类型。如果需要一个可空的数字（比如Int?）或者泛型，数字就会被装箱(boxed)：

1
2
3
4
5
6
7

val a: Int = 10000
print(a == a) // Prints 'true'
print(a === a) // Prints 'true'
val boxedA: Int? = a
val anotherBoxedA: Int? = a
print(boxedA == anotherBoxedA) // Prints 'true'
print(boxedA === anotherBoxedA) // !!!Prints 'false'!!!

==相当于调用equals方法。而===相当于Java中的==，用来比较引用对象。

注意在官方的Reference中用的是即将被deprecated的identityEquals，会得到错误的结果，详情参看 http://stackoverflow.com/questions/31666155/kotlins-identityequals-not-working-as-expected

Kotlin中，数字类型不能像Java一样隐式(implicitly)转换类型。

1
2
3

val a:Int? = 1
val b:Long? = a // 这里会编译报错，Int不能转换成Long
print(a == b) // 这里会编译报错，Int和Long不能进行比较

而所有的数字类型都有如下显示方法：

• toByte()
• toShort()
• toInt()
• toLong()
• toFloat()
• toDouble()
• toChar()

写惯Java的人可能觉得这样会很不方便，但事情也没有那么糟糕。因为运算符可以帮我们隐式的转换数字类型：

1

val l = 1.toLong() + 3 // Long + Int => Long

仅Int和Long可以进行位运算。运算符与Java不同：

• shl(bits) 有符号的左位移，在Java中是<<
• shr(bits) 有符号的右位移，在Java中是>>
• ushr(bits) 无符号的右位移，在Java中是>>>
• and(bits) 与，在Java中是&
• or(bits) 或，在Java中是|
• xor(bits) 异或，在Java中是^
• inv() 非，在Java中是~

Characters

Int不能直接转为Char，下面的代码会编译报错：

val a:Char = 1

但是Char可以通过toInt()方法转为Int。

同数字一样，如果需要一个可空类型（Char?），那么这个Char会被自动装箱（boxed）。

Booleans

没什么好说的，也是自动装箱的问题。

Arrays

Kotlin中的数组写法与Java区别很大，有专门的Array类来创建和操作数组。

如果我想创建一个[1, 2, 3]数组，可以这样写：

1
2

val a:Array<Int> = arrayOf(1, 2, 3) // 注意这里的数字装箱了
a[0] = a[1] + a[2] // 这里的操作与Java一样

还可以像这样写：

1
2

// Creates an Array<String> with values ["0", "1", "4", "9", "16"]
val asc = Array(5, {i -> (i * i).toString()})

如果想要一个空数组，可以使用arrayOfNulls(size: Int)方法。

如果不想装箱，Kotlin也提供一些原子类型（primitive type）的数组，如IntArray，ShortArray等。这些类型没有继承Array类型，但是拥有相同的方法。每个类型都有对应的工厂方法：

1
2

val x: IntArray = intArrayOf(1, 2, 3)
x[0] = x[1] + x[2]

Strings

s.[0]相当于Java中的s.charAt(0)

还可以使用iterator：

1
2
3

for (c in str) {
    println(c)
}

Kotlin包含两种类型的字符串：与Java字符串相同的escaped strings和新的raw strings。escaped strings中的换行符是\n，而raw strings就厉害了。看这个例子：

1
2
3
4

val text = """
    for (c in "foo")
    print(c)
"""

注意第二行和第三行都是字符串，它们被包含在三个引号中。

Kotlin中再也不用写繁琐的String.format了，只需要一个$：

1
2

val i = 10
val s = "i = $i" // evaluates to "i = 10"

甚至可以像这样写表达式：

1
2

val s = "abc"
val str = "$s.length is ${s.length}" // evaluates to "abc.length is 3"

这篇是用Typora写的，确实很好用，而且是国人出品！

Android程序员为什么要学Kotlin？

1. Java不争气。在1.5时代Java或许还能和C#谈笑风生，而现在C#不知道比Java高明到哪里去了。虽然Java8中也加入了闭包等有用的特性，但Android又不支持……
2. RxJava。想象这样一个需求：用户连续点击某个区域10次且每次间隔不超过500毫秒，则触发一个彩蛋。
   实现这个需求很容易，但代码会很混乱。我们得自己控制计时器，保存时间戳，可能还会有令人讨厌的空接口。如果用RxJava来做，几行代码就能搞定。如果再配合Kotlin的函数式编程，简直不能更爽~
   关于RxJava的使用，网上已经有很多了。我有空了可能也会写一些。
3. 如果你尝试了Android Databinding，有没有发现External Libraries里面多了kotlin-runtime和kotlin-stdlib？
   Google内部正是用Kotlin开发的Databinding。虽然短期内Kotlin还不太可能成为Android官方开发语言，但至少这是个好的迹象。

为什么是Kotlin？

现在替代Java的选择有很多，Scala、Groovy都能写Android，甚至微软最新发布的Visual Studio都能进来插一脚，为什么要选Kotlin呢？
这又是另一个很大的话题了。请参看大神Jake Wharton的这篇文章（要翻墙）。

那么进入正题。我的学习步骤基本是按照官方的Reference来，所以可能写着写着就成了翻译官方文档了……哈哈哈哈

Function

最开始学C的时候，我们会说为了实现XXX写个函数（Function），学Java就变成了写个方法（Method），现在Kotlin又变成函数了……
所以我后面提到Java的时候会说Method，提到Kotlin的时候会说Function，其实都是一个意思~

先看下Java中的写法

1
2
3

int sum(int a, int b) {
    return a + b;
}

然后是Kotlin

1
2
3

fun sum(a: Int, b: Int): Int {
    return a + b
}

区别：

1. 用fun开头
2. 数据类型写在后面
3. 结尾不用写分号

这语法让我想起了Action Script，写惯了Java再来写Kotlin总觉得有些别扭……

如果想简洁一点可以这样写在一行里，并且返回值类型可以是隐式（inferred）的。不过我个人不太喜欢这样写。

1

fun sum(a: Int, b: Int) = a + b

如果是public function就必须显式的标明返回类型

1

public fun sum(a: Int, b: Int): Int = a + b

没有返回值则用Unit关键字

1
2
3

fun printSum(a: Int, b: Int): Unit {
    print(a + b)
}

即使函数是public的，Unit也可以省略掉

1
2
3

public fun printSum(a: Int, b: Int) {
    print(a + b)
}

local variables

只读变量（read-only）用val定义

1
2
3
4

val a: Int = 1
val b = 1 // 如果赋了初始值值，可以省略数据类型
val c: Int // 否则需要指定类型
c = 1

可变变量（mutable）用var定义

1
2

var x = 5
x += 1

string templates

用${}包住变量就行了，这比Java中的String.valueof方便多了

1
2

val a = 1
print("Value of a: ${a}"}

conditional expressions

看起来有点像三元表达式，但可读性更强

1

fun max(a: Int, b: Int) = if (a > b) a else b

nullable values

写java的同学一定受够了NullPointerException吧。Kotlin与Java很大不同的一点就是显示的标明了value是否可能为空。
如果可能为空，则用?注明

1

var x: Int?

先知道有这么回事就行了，后面的章节会详细说明。

type checks & automatic casts

和C#一样，用is操作符来判断变量的类型

1
2
3
4
5
6

fun getStringLength(obj: Any): Int? {
    if (obj is String) {
        return obj.length // 注意这里obj已经自动转成String类型了，所以可以调用length方法
    }
    return null // 这里obj依然是Any类型
}

loop

和Java相比是把冒号改成了in

1
2
3
4

fun main(args: Array<String>) {
    for (arg in args)
        print(arg)
}

while loop

和Java基本一样

1
2
3
4
5

fun main(args: Array<String>) { 
    var i = 0
    while (i < args.size())
        print(args[i++]) 
}

when expression

when可以类比Java中的switch case，但是更加强大，可以接受各种操作符

1
2
3
4
5
6
7
8
9

fun cases(obj: Any) { 
    when (obj) {
        1 -> print("One")
        "Hello" -> print("Greeting")
        is Long -> print("Long")
        !is String -> print("Not a string")
        else -> print("Unknow")
    } 
}

ranges

in操作符太好用了，我就不贴对应的Java代码了，因为想想就觉得麻烦……

1
2
3
4
5
6
7
8

if (x in 1..y-1) 
    print("OK")
    
if (x !in 0..array.lastIndex) 
    print("Out")

for (x in 1..5) 
    print(x)

collections

collections配合in使用很方便

1
2

if (text in names) // 这里调用了names.contains(text) 
    print("Yes")

如果配合函数式编程和Lambdas表达式就不能更爽……

1
2
3
4

names filter { it.startsWith("A") } 
      sortBy { it } 
      map { it.toUpperCase() } 
      forEach { print(it) }

注意这里函数前面没有小圆点（.），这个大概是特有的简写，后面再慢慢学吧~

转曲

转曲的意思就是把文字转成曲线线段，可以想象成把文字的轮廓勾勒出来。
Android中的Paint.getTextPath
方法可以获得String的Path，而PathMeasure可以获得Path中的关键点。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
paint.setTextSize(yourTextSize);
Path fontPath = new Path();
paint.getTextPath(yourText, 0, yourText.length(), 0f, paint.getFontSpacing(), fontPath);
PathMeasure pathMeasure = new PathMeasure(fontPath, false);
float[] pos = new float[2]; // pos用来存放每一个关键点
do {
    float distance = 0f;
    while (distance < pathMeasure.getLength()) {
        pathMeasure.getPosTan(distance, pos, null);
        // 在这里将pos设置到你自己的曲线里
        // 我使用PDFjet生成PDF，那么这里就将pos保存到com.pdfjet.Point中
        distance += 0.1f; // 0.1f是每个关键点的间隔。间隔越大轮廓越粗糙，反之越细腻。如果设的过小会影响性能。
    }
} while (pathMeasure.nextContour());// nextContour会跳到下一段曲线

计算曲线嵌套层数

得到文字曲线后还不能直接印刷，因为我们只是得到了文字的轮廓，还得往轮廓里填色。
当然不能所有轮廓都填黑色，这样文字会变成一坨一坨的黑色……
我们需要计算每条曲线被多少条曲线全包围（注意我们现在得到的曲线全都是头尾相连的）。
如果被偶数条曲线（包含0条）包围，则填黑色；如果被奇数条曲线包围，则填白色（底色）。
Android或Java本身不提供这样的方法，还好已经有人帮我们研究出方法了，详细参看http://alienryderflex.com/polygon/。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

static class Polygon {
    // Polygon coodinates.
    private float[] polyY, polyX;
 
    // Number of sides in the polygon.
    private int polySides;
 
    /**
     * Default constructor.
     * @param px Polygon y coods.
     * @param py Polygon x coods.
     * @param ps Polygon sides count.
     */
    public Polygon( float[] px, float[] py, int ps ) {
        polyX = px;
        polyY = py;
        polySides = ps;
    }
 
    /**
     * Checks if the Polygon contains a point.
     * @see "http://alienryderflex.com/polygon/"
     * @param x Point horizontal pos.
     * @param y Point vertical pos.
     * @return Point is in Poly flag.
     */
    public boolean contains( float x, float y ) {
        boolean oddTransitions = false;
        for( int i = 0, j = polySides -1; i < polySides; j = i++ ) {
            if((Float.compare(polyY[i], y) < 0 && Float.compare(polyY[j], y) >= 0 ) || ( Float.compare(polyY[j], y) < 0 && Float.compare(polyY[i], y) >= 0)){
                if(Float.compare(polyX[i] + ( y - polyY[i] ) / ( polyY[j] - polyY[i] ) * ( polyX[j] - polyX[i] ), x) < 0 ) {
                    oddTransitions = !oddTransitions;
                }
            }
        }
        return oddTransitions;
    }
}

Polygon的构造方法前两个参数填多边形（可以将曲线理解为多边形）横坐标和纵坐标的数组，第三个参数填多边形的边数，即坐标的个数。
contains方法即可检查某个点是否在这个多边形中。
那么思路就很简单了：如果曲线A的任一关键点不在曲线B中，B就没有包围A。
代码就不贴了。

填色

如上所述，如果被偶数条曲线包围，填黑色；被奇数条曲线包围，填白色。

1
2
3
4
5
6
7

int nestingNum = surroundedNumber(pathPointsList, pathPoints);
if (nestingNum % 2 == 0) {
    paint.setColor(Color.BLACK);
} else {
    paint.setColor(Color.WHITE);
}
canvas.drawPath(path, paint);

大功告成~

详细代码请参考https://gist.github.com/qq157755587/32e927e77e259cd84631